 #include <stdio.h>
 #include <unistd.h>
 #include <stdbool.h>

 #include "ohos_init.h"
 #include "cmsis_os2.h"
 #include "iot_gpio.h"
 #include "iot_gpio_ex.h" // 需要用于GPIO扩展功能，如设置上下拉电阻
 #include "hi_io.h"       // 需要用于 hi_io_set_func
 #include "iot_pwm.h"
 #include "iot_errno.h"

 // --- 引脚定义 ---
 #define RED_LED_PIN     6
 #define GREEN_LED_PIN   5
 #define BLUE_LED_PIN    4

 // 按钮
 #define BUTTON_F1_GPIO     11 // 模式切换/循环按钮
 #define BUTTON_F2_GPIO     12 // 强制呼吸模式按钮

 // --- PWM 定义 --- (根据 hi_io.h 和 GPIO 引脚修正)
 #define RED_PWM_PORT    3 // GPIO 6 -> HI_IO_FUNC_GPIO_6_PWM3_OUT
 #define GREEN_PWM_PORT  2 // GPIO 5 -> HI_IO_FUNC_GPIO_5_PWM2_OUT
 #define BLUE_PWM_PORT   1 // GPIO 4 -> HI_IO_FUNC_GPIO_4_PWM1_OUT
 // #define IOT_PWM_PORT_PWM_MAX    4 // 似乎未使用
 #define LED_PWM_FUNCTION        5 // GPIO 复用功能码 (PWM)

 #define IOT_PWM_DUTY_MAX 99             // 最大占空比 (%)

 // --- 使用原始示例中的频率计算相关宏 ---
 #define PWM_FREQ_DIVITION       64000   // 分频值
 #define CLK_160M                160000000 // 系统时钟频率 (假设为160MHz)
 #define CALCULATED_PWM_FREQ     (CLK_160M / PWM_FREQ_DIVITION) // 约为 2500 Hz

 // --- 时序定义 ---
 #define BREATHE_STEP_DELAY_US   (10 * 1000) // 呼吸效果步进延迟 (10ms)
 #define FADE_STEP_DELAY_US      (15 * 1000) // 渐变效果步进延迟 (15ms)
 #define FLASH_DURATION_US       (200 * 1000) // 闪烁亮/灭持续时间 (200ms)
 #define TASK_LOOP_DELAY_MS      20          // 任务主循环中的小延迟 (ms)

 // --- 控制逻辑定义 ---
 #define NUM_BREATHE_CYCLES      3 // 呼吸循环次数
 #define NUM_FADE_CYCLES         3 // 顺序渐变循环次数
 #define STACK_SIZE              (4096*2) // 任务堆栈大小

 // --- 状态机 ---
 typedef enum {
     MODE_BREATHING,         // 呼吸模式
     MODE_SEQUENTIAL_FADE,   // 顺序渐变模式
     MODE_BUTTON1_CYCLE      // 按钮1循环模式
 } LedMode;

 // 全局状态变量 - volatile 因为会被中断服务程序修改
 static volatile LedMode g_currentMode = MODE_BREATHING; // 默认启动呼吸模式
 static volatile bool g_button1Pressed = false;
 static volatile bool g_button2Pressed = false;
 // 按钮1模式的子状态:
 // 0: 全亮等待 -> 按下闪烁R -> 状态1
 // 1: 全亮等待 -> 按下闪烁G -> 状态2
 // 2: 全亮等待 -> 按下闪烁B -> 状态3
 // 3: 全亮等待 -> 按下只亮R -> 状态4
 // 4: R亮等待  -> 按下只亮G -> 状态5
 // 5: G亮等待  -> 按下只亮B -> 状态6
 // 6: B亮等待  -> 按下全亮  -> 状态0
 static volatile int g_button1SubState = 0;

 // --- 函数声明 ---
 static void SetAllLedDuty(unsigned int duty);
 static void SetLedDuty(unsigned int port, unsigned int duty);
 static void StopAllLedPwm(void); // 修改：使用 IoTPwmStop
 static bool PerformSingleBreathe(void);
 static void PerformBreathingCycle(void);
 static bool PerformSingleFadeSequence(void);
 static void PerformSequentialFadeCycle(void);
 static void PerformButton1Flash(int colorIndex); // 修改：修正闪烁逻辑
 static void LedControlTask(void *arg);
 static void Button1_IsrFunc(char *arg);
 static void Button2_IsrFunc(char *arg);
 static void MultiLedControlDemo(void);


 // --- 辅助函数 ---

 // 重新初始化并启动所有 LED 的 PWM
 static void StartAllLedPwm(unsigned int duty)
 {
     if (duty > IOT_PWM_DUTY_MAX) duty = IOT_PWM_DUTY_MAX;
     // 根据建议，在 Start 前尝试 Init (虽然通常 Init 只需一次，但为确保状态可靠)
     // IoTPwmInit(RED_PWM_PORT); // 谨慎使用，可能导致重复初始化，先注释掉
     // IoTPwmInit(GREEN_PWM_PORT);
     // IoTPwmInit(BLUE_PWM_PORT);
     IoTPwmStart(RED_PWM_PORT, duty, CALCULATED_PWM_FREQ);
     IoTPwmStart(GREEN_PWM_PORT, duty, CALCULATED_PWM_FREQ);
     IoTPwmStart(BLUE_PWM_PORT, duty, CALCULATED_PWM_FREQ);
     printf("StartAllLedPwm: Started R(%d), G(%d), B(%d) with duty %u\n", RED_PWM_PORT, GREEN_PWM_PORT, BLUE_PWM_PORT, duty);
 }

 // 设置所有RGB LED的占空比 (使用 StartAllLedPwm 确保启动)
 static void SetAllLedDuty(unsigned int duty)
 {
     StartAllLedPwm(duty);
 }

 // 重新初始化并启动指定 LED 的 PWM
 static void StartSingleLedPwm(unsigned int port, unsigned int duty)
 {
     if (duty > IOT_PWM_DUTY_MAX) duty = IOT_PWM_DUTY_MAX;
     // IoTPwmInit(port); // 谨慎使用，先注释掉
     IoTPwmStart(port, duty, CALCULATED_PWM_FREQ);
     printf("StartSingleLedPwm: Started port %u with duty %u\n", port, duty);
 }

 // 设置指定LED的占空比 (使用 StartSingleLedPwm 确保启动)
 static void SetLedDuty(unsigned int port, unsigned int duty)
 {
      StartSingleLedPwm(port, duty);
 }

 // 停止所有LED的PWM输出 (修改为使用 IoTPwmStop)
 static void StopAllLedPwm(void)
 {
     IoTPwmStop(RED_PWM_PORT);
     IoTPwmStop(GREEN_PWM_PORT);
     IoTPwmStop(BLUE_PWM_PORT);
     printf("StopAllLedPwm: Stopped R(%d), G(%d), B(%d)\n", RED_PWM_PORT, GREEN_PWM_PORT, BLUE_PWM_PORT);
 }

 // 执行一次完整的呼吸（渐亮、渐灭），期间检查按键中断
 static bool PerformSingleBreathe(void)
 {
     // 渐亮
     for (unsigned int duty = 0; duty <= IOT_PWM_DUTY_MAX; duty++) {
         if (g_button1Pressed || g_button2Pressed) { StopAllLedPwm(); return false; }
         SetAllLedDuty(duty);
         // printf("Breathing Up - Duty: %u\n", duty); // 减少打印，避免过多日志
         usleep(BREATHE_STEP_DELAY_US);
     }
     // 渐灭
     for (unsigned int duty = IOT_PWM_DUTY_MAX; duty > 0; duty--) {
         if (g_button1Pressed || g_button2Pressed) { StopAllLedPwm(); return false; }
         SetAllLedDuty(duty);
         // printf("Breathing Down - Duty: %u\n", duty); // 减少打印
         usleep(BREATHE_STEP_DELAY_US);
     }
      if (g_button1Pressed || g_button2Pressed) { StopAllLedPwm(); return false; }
     StopAllLedPwm(); // 确保结束时熄灭 (使用新函数)
     printf("Breathing Cycle End\n");
     return true;
 }

 // 执行指定次数的呼吸循环
 static void PerformBreathingCycle(void)
 {
     printf("进入呼吸模式 (%d 次循环)\n", NUM_BREATHE_CYCLES);
     for (int i = 0; i < NUM_BREATHE_CYCLES; i++) {
         printf("呼吸循环 %d/%d\n", i + 1, NUM_BREATHE_CYCLES);
         if (!PerformSingleBreathe()) {
              printf("呼吸在第 %d 次循环中被中断\n", i + 1);
              // StopAllLedPwm() 已在 PerformSingleBreathe 中断时调用
              return; // 退出
         }
         // 两次呼吸之间短暂暂停，再次检查按钮
         if (g_button1Pressed || g_button2Pressed) {
             printf("呼吸在循环间被中断\n");
             StopAllLedPwm(); // 确保停止
             return;
         }
         usleep(200 * 1000); // 暂停200ms
     }
     // StopAllLedPwm(); // 正常完成后在 PerformSingleBreathe 最后已调用
     printf("呼吸模式完成\n");
     // 正常完成后，自动切换到顺序渐变模式
     if (!g_button1Pressed && !g_button2Pressed) {
         g_currentMode = MODE_SEQUENTIAL_FADE;
         printf("自动切换到顺序渐变模式\n");
     }
 }

 // 执行一次 R->G->B 顺序渐亮渐灭序列，期间检查按键中断
 static bool PerformSingleFadeSequence(void)
 {
     const unsigned int ports[] = {RED_PWM_PORT, GREEN_PWM_PORT, BLUE_PWM_PORT};
     const char* colors[] = {"红色", "绿色", "蓝色"};

     for (size_t i = 0; i < sizeof(ports) / sizeof(ports[0]); i++) {
         printf("顺序渐变: %s\n", colors[i]);
         // 渐亮
         for (unsigned int duty = 0; duty <= IOT_PWM_DUTY_MAX; duty++) {
             if (g_button1Pressed || g_button2Pressed) { StopAllLedPwm(); return false; }
             SetLedDuty(ports[i], duty);
             // printf("Fading Up %s - Duty: %u\n", colors[i], duty);
             usleep(FADE_STEP_DELAY_US);
         }
         // printf("Fading Up %s - Hold Max\n", colors[i]);
         usleep(100 * 1000); // 短暂保持最亮

         if (g_button1Pressed || g_button2Pressed) { StopAllLedPwm(); return false; }

         // 渐灭当前颜色
         // printf("顺序渐变: 渐灭 %s\n", colors[i]);
         for (unsigned int duty = IOT_PWM_DUTY_MAX; duty > 0; duty--) {
             if (g_button1Pressed || g_button2Pressed) { StopAllLedPwm(); return false; }
             SetLedDuty(ports[i], duty); // 渐灭也用 SetLedDuty (内部调用 Start)
             // printf("Fading Down %s - Duty: %u\n", colors[i], duty);
             usleep(FADE_STEP_DELAY_US);
         }

         IoTPwmStop(ports[i]); // 确保完全关闭当前颜色
         printf("Fading %s - Off\n", colors[i]);
         usleep(50 * 1000); // 短暂暂停
         if (g_button1Pressed || g_button2Pressed) { StopAllLedPwm(); return false; }
     }
     return true;
 }

 // 执行指定次数的顺序渐变循环
 static void PerformSequentialFadeCycle(void)
 {
     printf("进入顺序渐变模式 (%d 次循环)\n", NUM_FADE_CYCLES);
      for (int i = 0; i < NUM_FADE_CYCLES; i++) {
          printf("顺序渐变循环 %d/%d\n", i + 1, NUM_FADE_CYCLES);
          if (!PerformSingleFadeSequence()) {
               printf("顺序渐变在第 %d 次循环中被中断\n", i + 1);
               // StopAllLedPwm() 已在 PerformSingleFadeSequence 中断时调用
               return; // 退出
          }
          // 两次序列之间短暂暂停，再次检查按钮
          if (g_button1Pressed || g_button2Pressed) {
              printf("顺序渐变在循环间被中断\n");
              StopAllLedPwm();
              return;
          }
          usleep(200 * 1000); // 暂停 200ms
      }
      StopAllLedPwm(); // 正常完成后确保关闭
      printf("顺序渐变模式完成\n");
      // 正常结束后，自动切换回呼吸模式
      if (!g_button1Pressed && !g_button2Pressed) {
           g_currentMode = MODE_BREATHING;
           printf("自动切换回呼吸模式\n");
      }
 }


 // (修改) 闪烁指定颜色的LED一次 (灭 -> 亮 -> 延迟 -> 灭 -> 延迟 -> 回到全亮)
 static void PerformButton1Flash(int colorIndex) // 0=红, 1=绿, 2=蓝
 {
     const unsigned int ports[] = {RED_PWM_PORT, GREEN_PWM_PORT, BLUE_PWM_PORT};
     const char* colors[] = {"红灯", "绿灯", "蓝灯"};
     if (colorIndex < 0 || colorIndex >= 3) return;

     printf("按钮1模式: 准备闪烁 %s\n", colors[colorIndex]);

     usleep(50 * 1000); // 短暂延时确保停止生效
     IoTPwmInit(ports[colorIndex]); // 2. 初始化指定的PWM端口 (确保状态正确)
     SetLedDuty(ports[colorIndex], IOT_PWM_DUTY_MAX); // 2. 点亮选中的灯 (使用 Start)
     printf("Button1 Flash %s - ON (Duty: %d)\n", colors[colorIndex], IOT_PWM_DUTY_MAX);
     usleep(FLASH_DURATION_US);                       // 3. 保持点亮

     IoTPwmStop(ports[colorIndex]);                   // 4. 关闭灯 (使用 Stop)
     printf("Button1 Flash %s - OFF\n", colors[colorIndex]);
     usleep(FLASH_DURATION_US / 2);                   // 5. 短暂保持熄灭

     printf("闪烁完成，返回全亮状态\n");
     SetAllLedDuty(IOT_PWM_DUTY_MAX); // 6. 返回到所有LED都亮的状态 (使用 Start)
     printf("Button1 Mode - All ON (Duty: %d)\n", IOT_PWM_DUTY_MAX);
 }

 // --- 按钮中断服务程序 ---

 // 按钮1 (模式切换/循环) 的中断服务程序
 static void Button1_IsrFunc(char *arg)
 {
     (void)arg;
     // ISR 中仅设置标志，避免复杂操作和延时
     g_button1Pressed = true;
 }

 // 按钮2 (强制呼吸模式) 的中断服务程序
 static void Button2_IsrFunc(char *arg)
 {
     (void)arg;
     g_button2Pressed = true;
 }


 // --- 主任务 ---

 static void LedControlTask(void *arg)
 {
     (void)arg;
     // LedMode previousMode = g_currentMode; // 不再需要 previousMode
     bool stateChanged = true; // 用于标记模式切换，执行初始化操作

     StopAllLedPwm(); // 启动时先确保所有LED关闭
     printf("LedControlTask 启动，初始模式: %d\n", g_currentMode);

     while (1) {
         bool button1Trigger = false;
         bool button2Trigger = false;
         LedMode modeBeforeButtonCheck = g_currentMode; // 记录检查按钮前的模式

         // --- 检查按钮按下并处理 (带简单去抖动) ---
         if (g_button1Pressed) {
             osDelay(20); // 简单延时去抖
             if (g_button1Pressed) {
                 button1Trigger = true;
                 g_button1Pressed = false; // 清除标志
                 printf("检测到 Button 1 按下\n");
             } else {
                 printf("Button 1 抖动忽略\n");
             }
         }
         if (g_button2Pressed) {
            osDelay(20); // 简单延时去抖
            if (g_button2Pressed) {
                 button2Trigger = true;
                 g_button2Pressed = false; // 清除标志
                 printf("检测到 Button 2 按下\n");
            } else {
                 printf("Button 2 抖动忽略\n");
            }
         }

         // --- 处理模式切换 ---
         // 按钮2优先：强制切换到呼吸模式
         if (button2Trigger) {
             if (g_currentMode != MODE_BREATHING) {
                 printf("按钮2: 切换到呼吸模式\n");
                 StopAllLedPwm(); // 停止当前模式的灯
                 g_currentMode = MODE_BREATHING;
                 stateChanged = true; // 标记模式已改变
             } else {
                  printf("按钮2: 已在呼吸模式，重新开始\n");
                  StopAllLedPwm(); // 停止当前呼吸
                  stateChanged = true; // 强制重新执行呼吸初始化
             }
             // 清除按钮1标志，避免按钮2按下时同时处理按钮1的逻辑
             button1Trigger = false;
             g_button1Pressed = false;
         }

         // 处理按钮1：切换到循环模式或在循环模式内推进状态
         if (button1Trigger) {
             if (g_currentMode != MODE_BUTTON1_CYCLE) {
                 printf("按钮1: 首次按下，切换到按钮1循环模式\n");
                 StopAllLedPwm(); // 停止当前模式的灯
                 IoTPwmInit(RED_PWM_PORT);
                 IoTPwmInit(GREEN_PWM_PORT);
                 IoTPwmInit(BLUE_PWM_PORT);
                 printf("PWM 端口 %d, %d, %d 初始化完成。\n", RED_PWM_PORT, GREEN_PWM_PORT, BLUE_PWM_PORT);
                 g_currentMode = MODE_BUTTON1_CYCLE;
                 g_button1SubState = 0;    // 重置子状态为初始全亮
                 stateChanged = true;      // 标记模式已改变
                 // stateChanged 会在下面 case MODE_BUTTON1_CYCLE 中处理初始状态
             } else {
                 // 已经在按钮1循环模式, 按下则推进子状态
                 printf("按钮1: 在循环模式内按下，推进状态 (当前子状态: %d)\n", g_button1SubState);
                 switch (g_button1SubState) {
                     case 0: // 当前全亮 -> 闪烁 R
                         PerformButton1Flash(0); // Flash Red
                         g_button1SubState = 1;
                         printf("按钮1子状态: %d (等待闪烁G)\n", g_button1SubState);
                         break;
                     case 1: // 当前全亮 -> 闪烁 G
                         PerformButton1Flash(1); // Flash Green
                         g_button1SubState = 2;
                         printf("按钮1子状态: %d (等待闪烁B)\n", g_button1SubState);
                         break;
                     case 2: // 当前全亮 -> 闪烁 B
                         PerformButton1Flash(2); // Flash Blue
                         g_button1SubState = 3;
                         printf("按钮1子状态: %d (等待全灭)\n", g_button1SubState);
                         break;
                     case 3: // 当前全亮 -> 全灭
                         printf("按钮1动作: 只亮红灯\n");
                         StopAllLedPwm();
                         IoTPwmInit(RED_PWM_PORT);
                         IoTPwmInit(GREEN_PWM_PORT);
                         IoTPwmInit(BLUE_PWM_PORT);
                         printf("PWM 端口 %d, %d, %d 初始化完成。\n", RED_PWM_PORT, GREEN_PWM_PORT, BLUE_PWM_PORT);
                         g_button1SubState = 4;
                         printf("按钮1子状态: %d (等待亮R)\n", g_button1SubState);
                         break;
                     case 4: // 全灭 -> 亮 R
                         printf("按钮1动作: 只亮绿灯\n");
                         SetLedDuty(RED_PWM_PORT, IOT_PWM_DUTY_MAX);
                         g_button1SubState = 5;
                         printf("按钮1子状态: %d (等待亮G)\n", g_button1SubState);
                         break;
                     case 5: // 当前 R 亮 -> 只亮 RG
                         printf("按钮1动作: 只亮蓝灯\n");
                         SetLedDuty(BLUE_PWM_PORT, IOT_PWM_DUTY_MAX);
                         g_button1SubState = 6;
                         printf("按钮1子状态: %d (等待全亮)\n", g_button1SubState);
                         break;
                     case 6: // 当前 RG 亮 -> 全亮
                         printf("按钮1动作: 全亮 (循环回初始)\n");
                         SetAllLedDuty(IOT_PWM_DUTY_MAX);
                         g_button1SubState = 0;
                         printf("按钮1子状态: %d (回到初始)\n", g_button1SubState);
                         break;
                     default: // 异常状态，重置
                         printf("错误：按钮1子状态异常 (%d)，重置\n", g_button1SubState);
                         StopAllLedPwm();
                         SetAllLedDuty(IOT_PWM_DUTY_MAX);
                         g_button1SubState = 0;
                         break;
                 }
             }
         }

         // --- 执行当前模式逻辑 ---
         LedMode currentModeOnEntry = g_currentMode; // 记录进入 switch 时的模式

         // 如果模式刚刚改变，执行一次性设置
         if (stateChanged) {
              printf("模式切换或状态重置，当前模式: %d\n", g_currentMode);
              if (g_currentMode == MODE_BUTTON1_CYCLE && g_button1SubState == 0) {
                  printf("进入按钮1模式，设置初始状态：全亮\n");
                  SetAllLedDuty(IOT_PWM_DUTY_MAX); // 确保初始是全亮
              } else if (g_currentMode == MODE_BREATHING) {
                  printf("进入呼吸模式，准备开始循环\n");
                  // 呼吸模式的循环在 case 中处理
              } else if (g_currentMode == MODE_SEQUENTIAL_FADE) {
                   printf("进入顺序渐变模式，准备开始循环\n");
                  // 顺序渐变模式的循环在 case 中处理
              }
              stateChanged = false; // 清除改变标志
         }


         switch (g_currentMode) {
             case MODE_BREATHING:
                 // 只有当模式未在按钮处理中改变时才执行
                 if (currentModeOnEntry == MODE_BREATHING && !g_button1Pressed && !g_button2Pressed) {
                    PerformBreathingCycle();
                    // PerformBreathingCycle 会在内部检查按钮标志并可能改变模式
                    // 如果它正常完成或被中断，它会自行处理后续模式或返回
                 } else if (currentModeOnEntry != MODE_BREATHING) {
                     printf("模式在呼吸逻辑前已改变，跳过本次执行\n");
                 }
                 break;

             case MODE_SEQUENTIAL_FADE:
                  // 只有当模式未在按钮处理中改变时才执行
                 if (currentModeOnEntry == MODE_SEQUENTIAL_FADE && !g_button1Pressed && !g_button2Pressed) {
                    PerformSequentialFadeCycle();
                    // PerformSequentialFadeCycle 同上
                 } else if (currentModeOnEntry != MODE_SEQUENTIAL_FADE) {
                     printf("模式在顺序渐变逻辑前已改变，跳过本次执行\n");
                 }
                  break;

             case MODE_BUTTON1_CYCLE:
                 // 主要动作由按钮触发，此处仅保持状态
                 // 不需要做额外的事，因为状态（全亮或单色亮）由按钮处理逻辑设置
                 // printf("按钮1模式：等待按钮按下 (子状态 %d)\n", g_button1SubState);
                 break;

             default:
                 printf("错误: 未知的LED模式! %d\n", g_currentMode);
                 StopAllLedPwm(); // 关闭灯
                 g_currentMode = MODE_BREATHING; // 恢复到默认模式
                 stateChanged = true; // 触发模式重置
                 break;
         }

         // 短暂延时，让出 CPU，并允许检测中断标志变化
         osDelay(TASK_LOOP_DELAY_MS / (1000 / osKernelGetTickFreq()));
     }
 }

 // --- 初始化 ---
 static void InitPinsAndTask(void)
 {
     printf("启动多路LED控制演示...\n");

     // 1. 初始化LED的GPIO引脚
     IoTGpioInit(RED_LED_PIN);
     IoTGpioInit(GREEN_LED_PIN);
     IoTGpioInit(BLUE_LED_PIN);
     printf("GPIO %d, %d, %d 初始化完成。\n", RED_LED_PIN, GREEN_LED_PIN, BLUE_LED_PIN);

     // 2. 设置LED GPIO功能为PWM
     IoSetFunc(RED_LED_PIN, LED_PWM_FUNCTION);
     IoSetFunc(GREEN_LED_PIN, LED_PWM_FUNCTION);
     IoSetFunc(BLUE_LED_PIN, LED_PWM_FUNCTION);
     printf("GPIO %d, %d, %d 功能设置为 PWM (%d)。\n", RED_LED_PIN, GREEN_LED_PIN, BLUE_LED_PIN, LED_PWM_FUNCTION);

     // 3. 初始化PWM通道 (!!! 确保在任务启动前完成 !!!)
     IoTPwmInit(RED_PWM_PORT);
     IoTPwmInit(GREEN_PWM_PORT);
     IoTPwmInit(BLUE_PWM_PORT);
     printf("PWM 端口 %d, %d, %d 初始化完成。\n", RED_PWM_PORT, GREEN_PWM_PORT, BLUE_PWM_PORT);

     // 4. 初始化按钮
     // 按钮 1 (GPIO 11)
     IoTGpioInit(BUTTON_F1_GPIO);
     IoSetFunc(BUTTON_F1_GPIO, HI_IO_FUNC_GPIO_11_GPIO); // 显式使用 hi_io.h 中的枚举值
     IoTGpioSetDir(BUTTON_F1_GPIO, IOT_GPIO_DIR_IN);
     IoSetPull(BUTTON_F1_GPIO, HI_IO_PULL_UP); // 显式使用 hi_io.h 中的枚举值
     IoTGpioRegisterIsrFunc(BUTTON_F1_GPIO, IOT_INT_TYPE_EDGE, IOT_GPIO_EDGE_FALL_LEVEL_LOW, Button1_IsrFunc, NULL);
     printf("按钮 1 (GPIO %d) 初始化完成 (输入, 上拉, 下降沿中断)。\n", BUTTON_F1_GPIO);

     // 按钮 2 (GPIO 12)
     IoTGpioInit(BUTTON_F2_GPIO);
     IoSetFunc(BUTTON_F2_GPIO, HI_IO_FUNC_GPIO_12_GPIO); // 显式使用 hi_io.h 中的枚举值
     IoTGpioSetDir(BUTTON_F2_GPIO, IOT_GPIO_DIR_IN);
     IoSetPull(BUTTON_F2_GPIO, HI_IO_PULL_UP); // 显式使用 hi_io.h 中的枚举值
     IoTGpioRegisterIsrFunc(BUTTON_F2_GPIO, IOT_INT_TYPE_EDGE, IOT_GPIO_EDGE_FALL_LEVEL_LOW, Button2_IsrFunc, NULL);
     printf("按钮 2 (GPIO %d) 初始化完成 (输入, 上拉, 下降沿中断)。\n", BUTTON_F2_GPIO);


     // 5. 创建LED控制任务
     osThreadAttr_t attr = {0};
     attr.name = "LedControlTask";
     attr.stack_size = STACK_SIZE;
     attr.priority = osPriorityNormal;

     if (osThreadNew(LedControlTask, NULL, &attr) == NULL) {
         printf("[LedControlDemo] 创建 LedControlTask 失败!\n");
     } else {
         printf("LedControlTask 创建成功。\n");
     }
     printf("硬件初始化完成。LED任务已启动。\n");
 }

 // 修改 MultiLedControlDemo 为 InitPinsAndTask 并确保它被调用
 static void MultiLedControlDemo(void)
 {
     InitPinsAndTask();
 }

 // 注册应用程序功能入口
 APP_FEATURE_INIT(MultiLedControlDemo); // 确保入口点是这个函数